Sliding window

Find max

JavaScript

let fn = (arr) => {
  let left = 0;
  let ans = 0;
  let curr = 0;

  for (let right = 0; right < arr.length; right++) {
    // do logic here to add arr[right] to curr

    while (WINDOW_CONDITION_BROKEN) {
      // remove arr[left] from curr
      left++;
    }

    // update ans
    answer = Math.max(anser, right - left + 1);
  }

  return ans;
};

TypeScript

let fn = (arr: number[]): number => {
    let left = 0, ans = 0, curr = 0;

    for (let right = 0; right < arr.length; right++) {
        // Add arr[right] to curr
        curr += arr[right];

        while (/* WINDOW_CONDITION_BROKEN */) {
            // Remove arr[left] from curr
            curr -= arr[left];
            left++;
        }

        // Update ans based on the current window
        // ans = some logic to update ans based on curr
        answer = Math.max(anser, right - left + 1);
    }

    return ans;
}

Find min

JavaScript

var minSubArrayLen = function (target, nums) {
  let sum = 0;
  let left = 0;
  let ans = Infinity;

  for (let i = 0; i < nums.length; i++) {
    sum += nums[i];

    while (sum >= target) {
      sum -= nums[left];
      ans = Math.min(ans, i - left + 1);
      left++;
    }
  }

  return ans === Infinity ? 0 : ans;
};

TypeScript

var minSubArrayLen = function (target: number, nums: number[]): number {
  let sum = 0;
  let left = 0;
  let ans = Infinity;

  for (let i = 0; i < nums.length; i++) {
    sum += nums[i];

    while (sum >= target) {
      sum -= nums[left];
      ans = Math.min(ans, i - left + 1);
      left++;
    }
  }

  return ans === Infinity ? 0 : ans;
};

Example

Subarray Product Less Than K

Given an array of integers nums and an integer k, return the number of contiguous subarrays where the product of all the elements in the subarray is strictly less than k.

Input: nums = [10,5,2,6], k = 100
Output: 8
Explanation: The 8 subarrays that have product less than 100 are:
[10], [5], [2], [6], [10, 5], [5, 2], [2, 6], [5, 2, 6]
Note that [10, 5, 2] is not included as the product of 100 is not strictly less than k.

var numSubarrayProductLessThanK = function (nums, k) {
  if (k <= 1) return 0;

  let left = 0;
  let mult = 1;
  let ans = 0;

  for (let right = 0; right < nums.length; right++) {
    mult = mult * nums[right];

    while (mult >= k) {
      mult = mult / nums[left];
      left++;
    }

    ans += right - left + 1;
  }

  return ans;
};

Static window size

JavaScript

var findBestSubarray = function (nums, k) {
  let curr = 0;
  for (let i = 0; i < k; i++) {
    curr += nums[i];
  }

  let ans = curr;
  for (let i = k; i < nums.length; i++) {
    curr += nums[i] - nums[i - k];
    ans = Math.max(ans, curr);
  }

  return ans;
};

TypeScript

var findBestSubarray = function (nums: number[], k: number): number {
  let curr = 0;
  for (let i = 0; i < k; i++) {
    curr += nums[i];
  }

  let ans = curr;
  for (let i = k; i < nums.length; i++) {
    curr += nums[i] - nums[i - k];
    ans = Math.max(ans, curr);
  }

  return ans;
};